Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@litellm/entrypoint.py`:
- Around line 96-108: In the _parse_detail_date function, the current logic
calls .replace(tzinfo=timezone.utc) on all parsed datetime objects. This
approach is problematic for date strings that include timezone information
(those parsed with %z format specifiers like "%Y-%m-%dT%H:%M:%S%z"). When a
datetime with embedded timezone info is parsed, .replace() overwrites the tzinfo
without converting the time value, effectively corrupting the timestamp. Instead
of using .replace(tzinfo=timezone.utc) for all formats, check if the parsed
datetime already has tzinfo information (check if dt.tzinfo is not None), and if
it does, convert it to UTC using .astimezone(timezone.utc) to preserve the
correct time value; otherwise, use .replace(tzinfo=timezone.utc) for naive
datetimes.

In `@router/agy_proxy.py`:
- Around line 240-295: The issue is that google_breaker.is_allowed() and
vendor_breaker.is_allowed() are being called upfront at the beginning of the
function, which consumes probes for both breakers even if only one will actually
be used. This can unnecessarily block the vendor breaker if all requests succeed
on the Gemini tier. Remove the upfront calls to is_allowed() on both breakers
and instead call is_allowed() only when you're about to actually attempt a
specific tier in the for loop. Determine the appropriate breaker based on the
current tier's model name (checking if "gemini" is in the model_name), then call
is_allowed() on only that specific breaker before attempting to use it.

In `@router/main.py`:
- Around line 1556-1579: The current implementation generates a session_id by
hashing the user_key combined with the first 200 characters of the user message
content, which creates a security issue where two different conversations from
the same user with identical message prefixes will resume the wrong daemon
context. Remove the entire block that extracts first_user_content and generates
the fingerprint/session_id hash. Instead, only set session_id when the request
provides an explicit session identifier by checking for body.get("session_id"),
body.get("session"), request.headers.get("x-session-id"), or similar explicit
session keys directly without any content-based derivation.
- Around line 84-93: When Valkey has no cooldown key (val is None), the code
unconditionally resets _ollama_cooldown_until to 0.0, which clears any active
local cooldown that hasn't expired yet. In the else block following the `if val
is not None:` condition, preserve the existing _ollama_cooldown_until value if
it's still active (by checking if _ollama_cooldown_until is greater than
time.monotonic()). Only reset _ollama_cooldown_until to 0.0 if the local
cooldown has already expired or doesn't exist.
- Around line 1844-1853: The issue is in the calculation of _safe_max where
max(1024, _min_ctx - _est_input - 2048) creates a floor that masks over-context
scenarios. When the actual available tokens (_min_ctx - _est_input - 2048) falls
below 1024, the code still proceeds with the 1024-token floor, sending an
over-context request anyway. Instead, remove the max(1024, ...) floor and reject
the request entirely if the calculated safe max falls below a minimum acceptable
threshold (such as 1024 tokens), raising an appropriate exception rather than
proceeding with an invalid configuration.

In `@scripts/README.md`:
- Line 40: The documentation at line 40 in scripts/README.md hardcodes the
cooldown duration as "5-minute" when describing the fallback cascade behavior,
but the cooldown duration is actually configurable through environment
variables. Update the text to reflect that the cooldown is configurable rather
than a fixed value, and reference the specific environment variable setting that
controls this duration so users understand how to customize it and documentation
doesn't drift from the actual implementation.

In `@scripts/verification/verification_helpers.py`:
- Around line 26-28: In the function that processes lines to find
triage_requests_total, instead of returning immediately upon finding the first
match with the line that starts with "triage_requests_total", accumulate the
values from all matching lines and aggregate them (sum them together).
Initialize a total or sum variable before the loop, add each found value to it
as you iterate through all lines, and return the aggregated result after the
loop completes, rather than returning on the first match.

In `@scripts/verification/verify_direct_ollama_cooldown.py`:
- Around line 49-56: The verification logic for the cooldown test in the
conditional block starting with "if not success2 and '429' in response_msg2" is
incomplete. It should also verify that count_after_2 is greater than
count_after_1 to ensure the second request actually reached the triage router
before being rejected with a 429 status code. Add count_after_2 > count_after_1
as an additional condition to the existing check so the test only passes when
both the counter increased AND a 429 rejection occurred, preventing false
positives from upstream-only rejections.

In `@scripts/verification/verify_ollama_cooldown.py`:
- Around line 47-53: The fallback verification logic at the condition checking
`model_returned2 != "llm-routing-ollama"` is incomplete because it only rejects
the router name but not concrete Ollama model names (such as models starting
with "ollama-"). To fix this, enhance the condition to reject both the router
identifier "llm-routing-ollama" and any concrete Ollama model instances,
ensuring that any response indicating Ollama was used causes the fallback check
to fail as intended.

---

Outside diff comments:
In `@router/main.py`:
- Around line 2040-2103: The issue is that breaker.status() on line 2042
internally calls is_allowed() which consumes a probe, and this happens before
is_allowed_peek() is called on line 2103 for the metrics output. This means the
probe gets consumed by status() before the peek metric can accurately reflect
the non-consuming state. Replace the breaker.status() call with a version that
uses is_allowed_peek() instead of is_allowed() when computing the status,
ensuring the probe is not consumed until the actual peek metric collection later
in the function.

---

Nitpick comments:
In `@litellm/entrypoint.py`:
- Around line 62-64: The endpoints_paths variable is using list concatenation
with the + operator to combine a list containing os.path.join() result with the
glob.glob() result. Replace this with iterable unpacking by moving both elements
into a single list literal and using the unpacking operator (*) before
glob.glob() to expand its results directly into the list, resulting in cleaner
and more idiomatic Python code.

In `@router/agy_proxy.py`:
- Around line 328-332: The broad exception handler catching both
StopAsyncIteration and Exception silently hides real connection and read errors.
Refactor the exception handling in the block where r.aiter_lines() and
anext(lines_iter) are called to separately handle StopAsyncIteration (which
indicates an empty stream) and catch other exceptions to log them with details
before passing. This ensures actual errors during stream reading are visible for
debugging rather than being silently swallowed.

In `@scripts/verification/verify_ollama_routing.py`:
- Around line 13-21: Replace the manual `.env` parsing logic that reads and
extracts the LITELLM_MASTER_KEY value (the block starting with "if
os.path.exists(env_path)") with a call to the existing load_litellm_key()
function from verification_helpers.py. First import load_litellm_key from
verification_helpers, then replace the entire manual parsing block with a simple
assignment of litellm_key = load_litellm_key() to eliminate code duplication and
maintain consistency across scripts.